import { Injectable } from '@nestjs/common';
import { InjectRepository } from '@nestjs/typeorm';
import { In, Repository } from 'typeorm';
import { UserRole } from './entities/user-role.entity';

@Injectable()
export class UserRoleService {
  constructor(
    @InjectRepository(UserRole)
    private readonly userRoleRepository: Repository<UserRole>,
  ) {}

  /**
   * 根据用户id获取角色id
   * @param id
   */
  async getRoleIdByUser(id: number) {
    const userRole = await this.userRoleRepository.find({
      where: {
        user_id:id,
      },
    });
    return userRole.map((item) => item.role_id);
  }

  /**
   * 修改用户角色关联（新增、修改、删除）
   * @param id 用户id
   * @param roleIds 角色id数组
   */
  async updateUserRole(id: number, roleIds: number[]) {
    try {
      return await this.userRoleRepository.manager.transaction(
        async (manager) => {
          // 查找表中的用户角色
          const userRoles = await manager.find(UserRole, {
            where: {
              user_id: id,
            },
          });
          // 在roleIds中找出不在userRoles中的角色id，新增表中没有的用户角色
          let insertRows = roleIds.filter(
            (k) => !userRoles.some((j) => j.user_id == id && j.role_id == k),
          );
          if (insertRows && insertRows.length > 0) {
            await manager.insert(
              UserRole,
              insertRows.map((k) => {
                return {
                  user_id: id,
                  role_id: k,
                };
              }),
            );
          }

          // 在userRoles中找出roleIds所没有的，删除表中没有userRoles的用户角色
          let deleteRows = userRoles.filter(
            (k) => !roleIds.some((j) => j == k.role_id),
          );
          if (deleteRows && deleteRows.length > 0) {
            await manager.delete(UserRole, {
              user_id: id,
              role_id: In(deleteRows.map((k) => k.role_id)),
            });
          }
        },
      );
    } catch (err) {
      return err;
    }
  }
}
